// SPDX-FileCopyrightText: 2025 UnionTech Software Technology Co., Ltd.
// SPDX-License-Identifier: MIT

package utils

import (
	"fmt"
	"os"
	"path/filepath"
)

// SecurityIntegration 安全集成工具，用于在项目中统一处理敏感信息
type SecurityIntegration struct {
	securityUtils *SecurityUtils
	config        *SecurityConfig
}

// SecurityConfig 安全配置
type SecurityConfig struct {
	// 是否启用路径脱敏
	EnablePathSanitization bool
	// 是否启用错误信息脱敏
	EnableErrorSanitization bool
	// 是否启用邮箱屏蔽
	EnableEmailMasking bool
	// 是否启用IP屏蔽
	EnableIPMasking bool
	// 自定义敏感路径前缀
	CustomSensitivePrefixes []string
	// 是否启用调试模式（调试模式下保留更多信息）
	DebugMode bool
}

// NewSecurityIntegration 创建安全集成工具
func NewSecurityIntegration(config *SecurityConfig) *SecurityIntegration {
	if config == nil {
		config = DefaultSecurityConfig()
	}

	si := &SecurityIntegration{
		securityUtils: NewSecurityUtils(),
		config:        config,
	}

	// 添加自定义敏感路径前缀
	if len(config.CustomSensitivePrefixes) > 0 {
		// 这里可以扩展securityUtils来支持自定义前缀
		for _, prefix := range config.CustomSensitivePrefixes {
			// 在实际实现中，这里会添加到securityUtils的敏感模式列表中
			_ = prefix
		}
	}

	return si
}

// DefaultSecurityConfig 默认安全配置
func DefaultSecurityConfig() *SecurityConfig {
	return &SecurityConfig{
		EnablePathSanitization:  true,
		EnableErrorSanitization: true,
		EnableEmailMasking:      true,
		EnableIPMasking:         true,
		CustomSensitivePrefixes: []string{},
		DebugMode:               false,
	}
}

// SafeErrorf 安全的错误格式化函数，自动脱敏敏感信息
func (si *SecurityIntegration) SafeErrorf(format string, args ...interface{}) error {
	if !si.config.EnableErrorSanitization {
		return fmt.Errorf(format, args...)
	}

	// 脱敏格式化字符串中的参数
	sanitizedArgs := make([]interface{}, len(args))
	for i, arg := range args {
		sanitizedArgs[i] = si.SanitizeValue(arg)
	}

	return fmt.Errorf(format, sanitizedArgs...)
}

// SafeLogMessage 安全的日志消息处理
func (si *SecurityIntegration) SafeLogMessage(message string) string {
	if !si.config.EnableErrorSanitization {
		return message
	}
	return si.securityUtils.SanitizeErrorMessage(message)
}

// SanitizeValue 脱敏任意值
func (si *SecurityIntegration) SanitizeValue(value interface{}) interface{} {
	if !si.config.EnablePathSanitization && !si.config.EnableErrorSanitization {
		return value
	}

	switch v := value.(type) {
	case string:
		return si.SanitizeString(v)
	case error:
		return si.SanitizeError(v)
	case []string:
		return si.SanitizeStringSlice(v)
	case map[string]string:
		return si.SanitizeStringMap(v)
	default:
		// 对于其他类型，转换为字符串后处理
		str := fmt.Sprintf("%v", value)
		return si.SanitizeString(str)
	}
}

// SanitizeString 脱敏字符串
func (si *SecurityIntegration) SanitizeString(str string) string {
	if str == "" {
		return str
	}

	result := str

	// 脱敏路径
	if si.config.EnablePathSanitization {
		result = si.securityUtils.SanitizePath(result)
	}

	// 脱敏错误信息
	if si.config.EnableErrorSanitization {
		result = si.securityUtils.SanitizeErrorMessage(result)
	}

	// 调试模式下保留更多信息
	if si.config.DebugMode {
		// 在调试模式下，可以保留部分信息用于调试
		// 这里可以实现更复杂的逻辑
	}

	return result
}

// SanitizeError 脱敏错误信息
func (si *SecurityIntegration) SanitizeError(err error) error {
	if err == nil {
		return nil
	}

	// 如果已经是结构化错误，保持原样
	if structuredErr, ok := err.(interface{ Error() string }); ok {
		return structuredErr
	}

	// 脱敏错误消息
	sanitizedMsg := si.SanitizeString(err.Error())
	if sanitizedMsg == err.Error() {
		return err
	}

	return fmt.Errorf("%s", sanitizedMsg)
}

// SanitizeStringSlice 脱敏字符串切片
func (si *SecurityIntegration) SanitizeStringSlice(slice []string) []string {
	if slice == nil {
		return nil
	}

	result := make([]string, len(slice))
	for i, str := range slice {
		result[i] = si.SanitizeString(str)
	}
	return result
}

// SanitizeStringMap 脱敏字符串映射
func (si *SecurityIntegration) SanitizeStringMap(m map[string]string) map[string]string {
	if m == nil {
		return nil
	}

	result := make(map[string]string)
	for key, value := range m {
		sanitizedKey := si.SanitizeString(key)
		sanitizedValue := si.SanitizeString(value)
		result[sanitizedKey] = sanitizedValue
	}
	return result
}

// SafeFilePath 安全的文件路径处理
func (si *SecurityIntegration) SafeFilePath(path string) string {
	if !si.config.EnablePathSanitization {
		return path
	}
	return si.securityUtils.SanitizePath(path)
}

// SafeErrorMessage 安全的错误消息处理
func (si *SecurityIntegration) SafeErrorMessage(message string) string {
	if !si.config.EnableErrorSanitization {
		return message
	}
	return si.securityUtils.SanitizeErrorMessage(message)
}

// SafeEmail 安全的邮箱地址处理
func (si *SecurityIntegration) SafeEmail(email string) string {
	if !si.config.EnableEmailMasking {
		return email
	}
	return si.securityUtils.MaskEmail(email)
}

// SafeIP 安全的IP地址处理
func (si *SecurityIntegration) SafeIP(ip string) string {
	if !si.config.EnableIPMasking {
		return ip
	}
	return si.securityUtils.MaskIP(ip)
}

// ValidateAndSanitizePath 验证并清理路径
func (si *SecurityIntegration) ValidateAndSanitizePath(path string) (string, error) {
	if path == "" {
		return "", fmt.Errorf("path cannot be empty")
	}

	// 检查路径是否存在
	if _, err := os.Stat(path); err != nil {
		// 脱敏错误信息
		sanitizedPath := si.SafeFilePath(path)
		return "", fmt.Errorf("path validation failed for %s: %v", sanitizedPath, si.SanitizeError(err))
	}

	// 获取绝对路径
	absPath, err := filepath.Abs(path)
	if err != nil {
		sanitizedPath := si.SafeFilePath(path)
		return "", fmt.Errorf("failed to get absolute path for %s: %v", sanitizedPath, si.SanitizeError(err))
	}

	// 清理路径
	sanitizedPath := si.SafeFilePath(absPath)

	return sanitizedPath, nil
}

// SafeConfigDump 安全的配置转储（用于调试）
func (si *SecurityIntegration) SafeConfigDump(config interface{}) string {
	if si.config.DebugMode {
		// 调试模式下，可以返回更多信息
		return fmt.Sprintf("%+v", config)
	}

	// 生产模式下，只返回基本信息
	return "[CONFIG_REDACTED_FOR_SECURITY]"
}

// CreateSafeErrorContext 创建安全的错误上下文
func (si *SecurityIntegration) CreateSafeErrorContext(context map[string]interface{}) map[string]interface{} {
	if context == nil {
		return nil
	}

	safeContext := make(map[string]interface{})
	for key, value := range context {
		safeKey := si.SanitizeString(key)
		safeValue := si.SanitizeValue(value)
		safeContext[safeKey] = safeValue
	}
	return safeContext
}

// 全局安全集成实例
var globalSecurityIntegration *SecurityIntegration

// InitGlobalSecurity 初始化全局安全配置
func InitGlobalSecurity(config *SecurityConfig) {
	globalSecurityIntegration = NewSecurityIntegration(config)
}

// GetGlobalSecurity 获取全局安全集成实例
func GetGlobalSecurity() *SecurityIntegration {
	if globalSecurityIntegration == nil {
		InitGlobalSecurity(DefaultSecurityConfig())
	}
	return globalSecurityIntegration
}

// SafeErrorf 全局安全的错误格式化函数
func SafeErrorf(format string, args ...interface{}) error {
	return GetGlobalSecurity().SafeErrorf(format, args...)
}

// SafeLogMessage 全局安全的日志消息处理
func SafeLogMessage(message string) string {
	return GetGlobalSecurity().SafeLogMessage(message)
}

// SanitizeValue 全局脱敏任意值
func SanitizeValue(value interface{}) interface{} {
	return GetGlobalSecurity().SanitizeValue(value)
}

// SanitizeString 全局脱敏字符串
func SanitizeString(str string) string {
	return GetGlobalSecurity().SanitizeString(str)
}

// SanitizeError 全局脱敏错误信息
func SanitizeError(err error) error {
	return GetGlobalSecurity().SanitizeError(err)
}

// SafeFilePath 全局安全的文件路径处理
func SafeFilePath(path string) string {
	return GetGlobalSecurity().SafeFilePath(path)
}

// SafeErrorMessage 全局安全的错误消息处理
func SafeErrorMessage(message string) string {
	return GetGlobalSecurity().SafeErrorMessage(message)
}

// SafeEmail 全局安全的邮箱地址处理
func SafeEmail(email string) string {
	return GetGlobalSecurity().SafeEmail(email)
}

// SafeIP 全局安全的IP地址处理
func SafeIP(ip string) string {
	return GetGlobalSecurity().SafeIP(ip)
}

// ValidateAndSanitizePath 全局验证并清理路径
func ValidateAndSanitizePath(path string) (string, error) {
	return GetGlobalSecurity().ValidateAndSanitizePath(path)
}

// SafeConfigDump 全局安全的配置转储
func SafeConfigDump(config interface{}) string {
	return GetGlobalSecurity().SafeConfigDump(config)
}

// CreateSafeErrorContext 全局创建安全的错误上下文
func CreateSafeErrorContext(context map[string]interface{}) map[string]interface{} {
	return GetGlobalSecurity().CreateSafeErrorContext(context)
}
